package huawei_nowcoder;

import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
import java.util.stream.Collectors;

/**
 * @Description: 判断两个IP是否属于同一子网
 * @Date: 2020/4/23
 * @Author: 许群星
 */
public class JudgeIpIsSame {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            String mask = sc.next();
            String ip1 = sc.next();
            String ip2 = sc.next();
            System.out.println(checkNetSegment(mask, ip1, ip2));
        }
    }

    /**
     * 功能: 判断两台计算机IP地址是同一子网络。
     * 输入参数：    String Mask: 子网掩码，格式：“255.255.255.0”；
     * String ip1: 计算机1的IP地址，格式：“192.168.0.254”；
     * String ip2: 计算机2的IP地址，格式：“192.168.0.1”；
     * 返回值：      0：IP1与IP2属于同一子网络；
     * 1：IP地址或子网掩码格式非法；
     * 2：IP1与IP2不属于同一子网络
     */
    public static int checkNetSegment(String mask, String ip1, String ip2) {
        if (!ismask(mask) || !isEffective(ip1) || !isEffective(ip2)) {
            return 1;
        }
        //得到三个子串
        String binaryMask = toBinary(mask);
        String binaryIP1 = toBinary(ip1);
        String binaryIP2 = toBinary(ip2);

        int n = 0;
        while (n<32&&(binaryIP1.charAt(n) & binaryMask.charAt(n)) == (binaryIP2.charAt(n) & binaryMask.charAt(n))) {
            n++;
        }
        System.out.println("haha"+n);
        return n == 32 ? 0 : 2;
    }

    //十进制数字转化为二进制字符串
    public static String toBinary(String string) {
        String[] strings = string.split("\\.");
        String total = "";
        for (int i = 0; i < 4; i++) {
            long temp = Long.valueOf(strings[i]);
            String ans = "";
            while (temp > 1) {
                int haha = (int) (temp % 2);
                ans += haha;
                temp /= 2;
            }
            ans += temp;
            //小于8位的话转化为8位
            if (ans.length() < 8) {
                int between = 8 - ans.length();
                for (int j = 0; j < between; j++) {
                    ans += '0';
                }
            }

            //倒序
            String res = "";
            for (int j = ans.length() - 1; j >= 0; j--) {
                res += ans.charAt(j);
            }
            total += res;
        }

        return total;
    }

    //判断ip地址是否有效
    private static boolean isEffective(String ip) {
        String[] ipCharStr = ip.split("\\.");
        //判断ip是否为空或者首字符是否等于0
        Boolean isTrue = true;
        int number = Integer.parseInt(ipCharStr[0]);
        if (number == 0) {
            return false;              
        } else {
            for (int i = 0; i < ipCharStr.length; i++) {
                if (ipCharStr[i].length() <= 0 || ipCharStr[i] == "") {
                    return false;
                }
                int temp=Integer.parseInt(ipCharStr[i]);
                if (temp<0||temp>255) {
                    return false;
                }

            }
        }
        return true;
    }
    //判断掩码是否有效
    private static boolean ismask(String mask) {
        //判断掩码是否正确
        int[] codeRange = {254, 252, 248, 240, 224, 192, 128, 0};
        List<Integer> list = Arrays.stream(codeRange).boxed().collect(Collectors.toList());//int数组转化为list
        String[] codeCharStr = mask.split("\\.");

        //判断是否前面全为1后面全为0
        if ("255".equals(codeCharStr[0])) {
            if ("255".equals(codeCharStr[1])) {
                if ("255".equals(codeCharStr[2])) {
                    if ("255".equals(codeCharStr[3])) {
                        return false;
                    } else if (list.contains(Integer.parseInt(codeCharStr[3]))) {
                        return true;
                    } else {
                        return false;
                    }
                } else if (list.contains(Integer.parseInt(codeCharStr[2]))) {
                    if (Integer.parseInt(codeCharStr[3]) == 0) {
                        return true;
                    } else {
                        return false;
                    }
                } else {
                    return false;
                }
            } else if (list.contains(Integer.parseInt(codeCharStr[1]))) {
                if (Integer.parseInt(codeCharStr[2]) == 0 && Integer.parseInt(codeCharStr[3]) == 0) {
                    return true;
                } else {
                    return false;
                }
            } else {
                return false;
            }
        } else if (list.contains(Integer.parseInt(codeCharStr[0]))) {
            if (Integer.parseInt(codeCharStr[0]) == 0) {
                return false;
            } else {
                if (Integer.parseInt(codeCharStr[1]) == 0 && Integer.parseInt(codeCharStr[2]) == 0 && Integer.parseInt(codeCharStr[3]) == 0) {
                    return true;
                } else {
                    return false;
                }
            }

        } else {
            return false;
        }
    }
    
}
/*
题目描述
子网掩码是用来判断任意两台计算机的IP地址是否属于同一子网络的根据。
子网掩码与IP地址结构相同，是32位二进制数，其中网络号部分全为“1”和主机号部分全为“0”。
利用子网掩码可以判断两台主机是否中同一子网中。若两台主机的IP地址分别与它们的子网掩码相“与”后的结果相同，则说明这两台主机在同一子网中。

示例：
I P 地址　 192.168.0.1
子网掩码　 255.255.255.0
转化为二进制进行运算：
I P 地址　11010000.10101000.00000000.00000001
子网掩码　11111111.11111111.11111111.00000000
AND运算
 　　　　11000000.10101000.00000000.00000000
转化为十进制后为：
 　　　　192.168.0.0

I P 地址　 192.168.0.254
子网掩码　 255.255.255.0
转化为二进制进行运算：
I P 地址　11010000.10101000.00000000.11111110
子网掩码　11111111.11111111.11111111.00000000
AND运算
　　　　　11000000.10101000.00000000.00000000
转化为十进制后为：
　　　　　192.168.0.0
通过以上对两台计算机IP地址与子网掩码的AND运算后，我们可以看到它运算结果是一样的。均为192.168.0.0，所以这二台计算机可视为是同一子网络。
输入描述:
输入子网掩码、两个ip地址
输出描述:
得到计算结果
示例1
输入
复制
255.255.255.0 192.168.224.256 192.168.10.4

255.255.255.0 192.168.0.1 192.168.0.254
输出
复制
1
 */